use uuid::Uuid; // Rust中的UUID库
use std::collections::HashMap; // Rust中的HashMap，用于模拟Java中的Map
use std::collections::HashSet; // Rust中的HashSet，用于模拟Java中的Collection

/// 字符串工具
///
/// @since 2.0
pub struct StrUtils;

impl StrUtils {
    /// 生成 guid
    pub fn guid() -> String {
        Uuid::new_v4().to_string().replace("-", "")
    }

    /// 检查字符串是否为空
    ///
    /// # 参数
    /// - `s`：字符串
    pub fn is_empty(s: &str) -> bool {
        s.is_empty()
    }

    /// 检查集合是否为空
    ///
    /// # 参数
    /// - `s`：集合
    pub fn is_collection_empty<T>(s: &HashSet<T>) -> bool {
        s.is_empty()
    }

    /// 检查Map是否为空
    ///
    /// # 参数
    /// - `s`：Map
    pub fn is_map_empty<K, V>(s: &HashMap<K, V>) -> bool {
        s.is_empty()
    }

    /// 检查字符串是否为非空
    ///
    /// # 参数
    /// - `s`：字符串
    pub fn is_not_empty(s: &str) -> bool {
        !StrUtils::is_empty(s)
    }

    /// 检查集合是否非空
    ///
    /// # 参数
    /// - `s`：集合
    pub fn is_collection_not_empty<T>(s: &HashSet<T>) -> bool {
        !StrUtils::is_collection_empty(s)
    }
}

// fn main() {
//     // 示例使用
//     let guid = StrUtils::guid();
//     println!("Generated GUID: {}", guid);
//
//     let empty_str = "";
//     println!("Is empty string: {}", StrUtils::is_empty(empty_str));
//
//     let mut set = HashSet::new();
//     println!("Is empty collection: {}", StrUtils::is_collection_empty(&set));
//     set.insert(1);
//     println!("Is not empty collection: {}", StrUtils::is_collection_not_empty(&set));
//
//     let mut map = HashMap::new();
//     println!("Is empty map: {}", StrUtils::is_map_empty(&map));
//     map.insert("key", "value");
//     println!("Is not empty map: {}", !StrUtils::is_map_empty(&map));
// }
#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::{HashMap, HashSet};

    #[test]
    fn test_guid() {
        let guid = StrUtils::guid();
        assert_eq!(guid.len(), 32); // 检查GUID长度是否为32
    }

    #[test]
    fn test_is_empty_string() {
        assert!(StrUtils::is_empty(""));
        assert!(!StrUtils::is_empty("not empty"));
    }

    #[test]
    fn test_is_collection_empty() {
        let empty_set: HashSet<i32> = HashSet::new();
        let mut non_empty_set: HashSet<i32> = HashSet::new();
        non_empty_set.insert(1);
        assert!(StrUtils::is_collection_empty(&empty_set));
        assert!(!StrUtils::is_collection_empty(&non_empty_set));
    }

    #[test]
    fn test_is_map_empty() {
        let empty_map: HashMap<i32, i32> = HashMap::new();
        let mut non_empty_map: HashMap<i32, i32> = HashMap::new();
        non_empty_map.insert(1, 1);
        assert!(StrUtils::is_map_empty(&empty_map));
        assert!(!StrUtils::is_map_empty(&non_empty_map));
    }

    #[test]
    fn test_is_not_empty_string() {
        assert!(StrUtils::is_not_empty("not empty"));
        assert!(!StrUtils::is_not_empty(""));
    }

    #[test]
    fn test_is_collection_not_empty() {
        let empty_set: HashSet<i32> = HashSet::new();
        let mut non_empty_set: HashSet<i32> = HashSet::new();
        non_empty_set.insert(1);
        assert!(!StrUtils::is_collection_not_empty(&empty_set));
        assert!(StrUtils::is_collection_not_empty(&non_empty_set));
    }
}